コマンド/Press to code/応用編

 let Pos1, Pos2, Pos3;
 let selectedBlocks = [];
 let blockQueue = [];
 let undoStack = [];
 tick = () => {
    const maxPerTick = 20;
    for (let i = 0; i < maxPerTick && blockQueue.length > 0; i++) {
        const { pos, block } = blockQueue.shift();
        const blockToSet = Array.isArray(block) ? block[0] : block;
        api.setBlock(pos, blockToSet);
    }
 };
 function cubicBezier(t, p0, p1, p2, p3) {
    const u = 1 - t;
    const tt = t * t;
    const uu = u * u;
    const uuu = uu * u;
    const ttt = tt * t;

    return [
        uuu * p0[0] + 3 * uu * t * p1[0] + 3 * u * tt * p2[0] + ttt * p3[0],
        uuu * p0[1] + 3 * uu * t * p1[1] + 3 * u * tt * p2[1] + ttt * p3[1],
        uuu * p0[2] + 3 * uu * t * p1[2] + 3 * u * tt * p2[2] + ttt * p3[2],
    ];
 }
 function perpendicular2D(vec) {
    return [-vec[2], 0, vec[0]];
 }
 function midpoint(p1, p2) {
    return [
        (p1[0] + p2[0]) / 2,
        (p1[1] + p2[1]) / 2,
        (p1[2] + p2[2]) / 2,
    ];
 }
 function enqueueBlock(pos, block) {
    blockQueue.push({ pos, block });
 }
 onPlayerSelectInventorySlot = (playerId, slotIndex) => {
    const held = api.getHeldItem(playerId);
    if (!held || held.name !== "Wood Axe") return;

    if (!Pos1 || !Pos3) return;

    const isLine = !Pos2;
    const p2 = isLine ? midpoint(Pos1, Pos3) : Pos2;
    const steps = 120;

    for (let i = 0; i <= steps; i += 5) {
        const t = i / steps;
        const pos = cubicBezier(t, Pos1, p2, p2, Pos3);
        const [x, y, z] = pos;
        api.playParticleEffect({
            dir1: [-1, -1, -1],
            dir2: [1, 1, 1],
            pos1: [x, y + 1, z],
            pos2: [x + 1, y + 2, z + 1],
            texture: "bubble",
            minLifeTime: 10.0,
            maxLifeTime: 10.0,
            minEmitPower: 2,
            maxEmitPower: 2,
            minSize: 0.25,
            maxSize: 0.35,
            manualEmitCount: 20,
            gravity: [0, 0, 0],
            colorGradients: [
                {
                    timeFraction: 0,
                    minColor: [60, 60, 150, 1],
                    maxColor: [200, 200, 255, 1],
                },
            ],
            velocityGradients: [
                {
                    timeFraction: 0,
                    factor: 0,
                    factor2: 0,
                },
            ],
            blendMode: 1,
        });
    }
 };
 onPlayerChangeBlock = (pId, x, y, z, fromBlock) => {
    const held = api.getHeldItem(pId);
    if (!held || held.name !== "Wood Axe") return;
    api.setBlock(x, y, z, fromBlock);
    selectedBlocks.push(fromBlock);
    api.sendMessage(pId, `ストックに ${fromBlock} を追加しました（${selectedBlocks.length}個目）`);
 };
 playerCommand = (pId, command, args) => {
    const pos = api.getPosition(pId);

    if (command === "pos1") {
        Pos1 = pos;
        api.sendMessage(pId, "Pos1 を設定しました");
        return true;
    }
    if (command === "pos2") {
        Pos2 = pos;
        api.sendMessage(pId, "Pos2 を設定しました");
        return true;
    }
    if (command === "pos3") {
        Pos3 = pos;
        api.sendMessage(pId, "Pos3 を設定しました");
        return true;
    }
    if (command === "clear") {
        selectedBlocks = [];
        api.sendMessage(pId, "ストックをクリアしました");
        return true;
    }
    if (command === "undo") {
        if (undoStack.length === 0) {
            api.sendMessage(pId, "元に戻スモモのがありません");
            return true;
        }
        const last = undoStack.pop();
        for (const { pos } of last) {
            enqueueBlock(pos, "Air");
        }
        api.sendMessage(pId, "直前の設置を元に戻しました");
        return true;
    }
        if (command === "setcurves" || command === "setline") {
        if (!Pos1 || !Pos3 || (command === "test" && !Pos2)) {
            api.sendMessage(pId, "Pos1～Pos3を設定してください");
            return true;
        }
        const p2 = (command === "setline") ? midpoint(Pos1, Pos3) : Pos2;
        const steps = 120;
        const placed = [];
        for (let i = 0; i <= steps; i++) {
            const t = i / steps;
            const nextT = Math.min((i + 1) / steps, 1);
            const pos = cubicBezier(t, Pos1, p2, p2, Pos3);
            const nextPos = cubicBezier(nextT, Pos1, p2, p2, Pos3);
            const tangent = [nextPos[0] - pos[0], 0, nextPos[2] - pos[2]];
            const len = Math.hypot(tangent[0], tangent[2]);
            if (len === 0) continue;
            const dir = [tangent[0] / len, 0, tangent[2] / len];
            const normal = perpendicular2D(dir);
            for (let j = 0; j < selectedBlocks.length; j++) {
                const offset = j - Math.floor(selectedBlocks.length / 2);
                const bx = Math.floor(pos[0] + normal[0] * offset);
                const bz = Math.floor(pos[2] + normal[2] * offset);
                const by = Math.floor(pos[1]);
                const blockType = selectedBlocks[j];
                if (blockType) {
                    const bpos = [bx, by, bz];
                    enqueueBlock(bpos, blockType);
                    placed.push({ pos: bpos });
                }
            }
        }
        undoStack.push(placed);
        api.sendMessage(pId, `${command} で設置を実行しました`);
        return true;
    }
    return false;
 };

 let melody = [
    { note: 'F4', duration: 12 },
    { note: 'F4', duration: 12 },
    { note: 'F4', duration: 12 },
    { note: 'G4', duration: 12 },

    { note: 'A4', duration: 12 },
    { note: 'A4', duration: 12 },
    { note: 'rest', duration: 6 },
    { note: 'A4', duration: 12 },
    { note: 'G4', duration: 12 },

    { note: 'F4', duration: 12 },
    { note: 'F4', duration: 12 },
    { note: 'F4', duration: 12 },
    { note: 'D4', duration: 12 },

    { note: 'rest', duration: 6 },
    { note: 'D4', duration: 12 },
    { note: 'D4', duration: 12 },

    { note: 'rest', duration: 6 },
    { note: 'D4', duration: 12 },
    { note: 'F4', duration: 12 },

    { note: 'F4', duration: 12 },
    { note: 'F4', duration: 12 },
    { note: 'A4', duration: 12 },
    { note: 'A4', duration: 12 },

    { note: 'G4', duration: 12 },
    { note: 'G4', duration: 12 },
    { note: 'F4', duration: 12 },

    { note: 'A4', duration: 12 },
    { note: 'C4', duration: 18 },
    { note: 'F4', duration: 12 },
 ];
 let noteRates = {
    'C4': 1.56194,  // ド
    'D4': 1.75222,  // レ
    'E4': 1.85670,  // ミ
    'F4': 2.08358,  // ファ
    'G4': 2.33880,  // ソ
    'A4': 2.62686,  // ラ
    'B4': 2.78208,  // シ
    'C5': 3.12388,  // 高ド
    'D5': 3.50444,  // 高レ
 };

 let currentNoteIndex = 0;
 let noteCounter = 0;

 tick = (dt) => {
    if (currentNoteIndex >= melody.length) return;

    let current = melody[currentNoteIndex];

    if (noteCounter === 0) {
        api.getPlayerIds().forEach(playerId => {
            let rate = noteRates[current.note];
            if (rate !== undefined) {
                api.playSound(playerId, "beep", 1, rate, { playerIdOrPos: playerId });
            }
        });
    }
    noteCounter++;
    if (noteCounter >= current.duration) {
        currentNoteIndex++;
        noteCounter = 0;
    }
 }

 let melody = [
   { note: 'C4', duration: 12 },  // ドー
   { note: 'D4', duration: 6 },  // レー
   { note: 'E4', duration: 12 },  // ミー
   { note: 'C4', duration: 6 },   // ド
   { note: 'E4', duration: 12 },  // ミー
   { note: 'C4', duration: 8 },   // ド
   { note: 'E4', duration: 12 },  // ミー
 ];

 let noteRates = {
   'C4': 1.56194,  // ド
   'D4': 1.75222,  // レ
   'E4': 2.00000,  // ミ
   'F4': 2.08358,  // ファ
   'G4': 2.33880,  // ソ
   'A4': 2.62686,  // ラ
   'B4': 2.78208,  // シ
   'C5': 3.12388,  // 高ド
   'D5': 3.50444,  // 高レ
 };

 let currentNoteIndex = 0;
 let noteCounter = 0;

 tick = (dt) => {
   if (currentNoteIndex >= melody.length) return;
   let current = melody[currentNoteIndex];
   if (noteCounter === 0) {
       api.getPlayerIds().forEach(playerId => {
           let rate = noteRates[current.note];
           if (rate !== undefined) {
               api.playSound(playerId, "beep", 1, rate, { playerIdOrPos: playerId });
           }
       });
   }
   noteCounter++;
   if (noteCounter >= current.duration) {
       currentNoteIndex++;
       noteCounter = 0;
   }
 };

 const START_BLOCK = "スタートするブロック";
 const GOAL_BLOCK = "ゴールするブロック";
 const RESET_BLOCK = "一回スタートしたけどもう一回リセットするブロック";
 const playerStartTimes = new Map();
 const playerLastStates = new Map();
 tick = () => {
    const playerIds = api.getPlayerIds();
    for (const playerId of playerIds) {
        const standingBlocks = api.getBlockTypesPlayerStandingOn(playerId);
        const isOnStart = standingBlocks.includes(START_BLOCK);
        const isOnGoal = standingBlocks.includes(GOAL_BLOCK);
        const isOnReset = standingBlocks.includes(RESET_BLOCK);
        // 前回の状態を取得（なければ初期化）
        const lastState = playerLastStates.get(playerId) || {
            onStart: false,
            onGoal: false,
            onReset: false
        };
        if (!playerStartTimes.has(playerId)) {
            if (isOnStart && !lastState.onStart) {
                playerStartTimes.set(playerId, Date.now());
                api.sendMessage(playerId, "スタート!", { color: "yellow" });
            }
        } else {
            if (isOnReset && !lastState.onReset) {
                playerStartTimes.delete(playerId);
                api.sendMessage(playerId, "やり直してタイマーをストップしました", { color: "yellow" });
            }
            else if (isOnGoal && !lastState.onGoal) {
                const startTime = playerStartTimes.get(playerId);
                if (startTime !== undefined) {
                    const endTime = Date.now();
                    const elapsedSeconds = ((endTime - startTime) / 1000).toFixed(2);
                    const playerName = api.getEntityName(playerId);
                    api.broadcastMessage(
                        `${playerName}が${elapsedSeconds}秒でゴールしました`,
                        { color: "yellow" }
                    );
                    playerStartTimes.delete(playerId);
                }
            }
        }
        playerLastStates.set(playerId, {
            onStart: isOnStart,
            onGoal: isOnGoal,
            onReset: isOnReset
        });
    }
 };

 const centerX = 0.5;
 const centerY = 0;
 const centerZ = 0.5;
 const radius = 10; //半径

 let angle = 0;
 const angleStep = 5; // 度単位、角度が細かいほど滑らか

 while (angle < 360) {
    const radians = angle * Math.PI / 180;
    const x = Math.round(centerX + radius * Math.cos(radians));
    const z = Math.round(centerZ + radius * Math.sin(radians));
    const y = centerY;

    api.setBlock(x, y, z, "Block of Diamond");

    angle += angleStep;
 }

 const centerX = 0.5;
 const centerY = 0.5;
 const centerZ = 0.5;
 const radius = 10; //半径

 const blockName = "Block of Diamond";
 const thickness = 0.5; // 表面の厚み許容範囲(いじらなくてもよし)

 let x = -radius;
 while (x <= radius) {
    let y = -radius;
    while (y <= radius) {
        let z = -radius;
        while (z <= radius) {
            const distance = Math.sqrt(x * x + y * y + z * z);
            if (Math.abs(distance - radius) <= thickness) {
                const worldX = centerX + x;
                const worldY = centerY + y;
                const worldZ = centerZ + z;
                api.setBlock(worldX, worldY, worldZ, blockName);
            }
            z++;
        }
        y++;
    }
    x++;
 }

 Mb_rpos = [0,0,0]; //ここを表の0番目のcodeblockの座標を書く
 Mb_rpos = [Mb_rpos[0] - 2,Mb_rpos[1] - 1,Mb_rpos[2] - 2]
 Mb_ch = [0,0,0,0,0,0,0,0,0];
 is_turn = 1;

 Mb_ch_Number = 0;

 for(Mb_ch_Number = 0; Mb_ch_Number < 9; Mb_ch_Number++){

	Mb_x_ofset_pos = Math.floor(Mb_ch_Number / 3) * 4;
	Mb_z_ofset_pos = (Mb_ch_Number % 3) * 4;

	Mb_start_pos = [Mb_pos[0] + Mb_x_ofset_pos,Mb_pos[1],Mb_pos[2] + Mb_z_ofset_pos];
	Mb_goal_pos = [Mb_start_pos[0] + 2,Mb_start_pos[1],Mb_start_pos[2] + 2];

	api.setBlockRect(Mb_start_pos,Mb_goal_pos,"White Wool")
 }
 wins = 0;
 win = "false"

 Mb_ch_Number = 中の数字;
 Mb_x_ofset_pos = Math.floor(Mb_ch_Number / 3) * 4;
 Mb_z_ofset_pos = (Mb_ch_Number % 3) * 4;
 Mb_start_pos = [Mb_pos[0] + Mb_x_ofset_pos,Mb_pos[1],Mb_pos[2] + Mb_z_ofset_pos];
 Mb_goal_pos = [Mb_start_pos[0] + 2,Mb_start_pos[1],Mb_start_pos[2] + 2];
 if(Mb_ch[Mb_ch_Number] == 0){
	Mb_ch[Mb_ch_Number] = is_turn;
		if(is_turn == 1){
				api.setBlockRect(Mb_start_pos,Mb_goal_pos,"Red Wool")
			is_turn++
		}else{
			is_turn = 1;
				api.setBlockRect(Mb_start_pos,Mb_goal_pos,"Blue Wool")
	}
 }
 if(wins == 0){
 win = "false"
 for (i = 0; i < 9; i = i + 3){
	if( (Mb_ch[i] != 0) && (Mb_ch[i] == Mb_ch[i + 1]) && (Mb_ch[i] == Mb_ch[i + 2]) ){
		win = "true"
	}
 }
 for (i = 0; i < 3; i++){
	if( (Mb_ch[i] != 0) && (Mb_ch[i] == Mb_ch[i + 3]) && (Mb_ch[i] == Mb_ch[i + 6]) ){
		win = "true"
	}
 }
 if( (Mb_ch[0] != 0) && (Mb_ch[0] == Mb_ch[4]) && (Mb_ch[0] == Mb_ch[8]) ){
	win = "true"
 }
 if( (Mb_ch[2] != 0) && (Mb_ch[2] == Mb_ch[4]) && (Mb_ch[2] == Mb_ch[6]) ){
	win = "true"
 }
 if(win == "true"){
	if(is_turn == 1){
		api.broadcastMessage("[OXゲ一ム]",{color : "yellow"})
		api.broadcastMessage("青が勝ちました",{color : "blue"})
	}else{
		api.broadcastMessage("[OXゲ一ム]",{color : "yellow"})
		api.broadcastMessage("赤が勝ちました",{color : "red"})
	}
 wins++
 }
 }

 let count = 0;
 let pos1 = null;
 let pos2 = null;
 let posSelected1 = false;
 let posSelected2 = false;
 let Obtained = false;
 let vertices = [];
 playerCommand = (myId, command) => {
    if (command === "/pos1") {
        let position_one = api.getPosition(playerId);
        pos1 = position_one.map(Math.floor);
        posSelected1 = true;
    }

    if (command === "/pos2") {
        let position_two = api.getPosition(playerId);
        pos2 = position_two.map(Math.floor);
        posSelected2 = true;

        if (posSelected1 && posSelected2) {
            let x_min = Math.min(pos1[0], pos2[0]);
            let x_max = Math.max(pos1[0], pos2[0]);
            let y_min = Math.min(pos1[1], pos2[1]);
            let y_max = Math.max(pos1[1], pos2[1]);
            let z_min = Math.min(pos1[2], pos2[2]);
            let z_max = Math.max(pos1[2], pos2[2]);

            vertices = [
                [x_min, y_min, z_min], [x_min, y_min, z_max],
                [x_min, y_max, z_min], [x_min, y_max, z_max],
                [x_max, y_min, z_min], [x_max, y_min, z_max],
                [x_max, y_max, z_min], [x_max, y_max, z_max]
            ];
            Obtained = true;
        }
    }
    if (command.startsWith("/fill") || command.startsWith("/set")){
        posSelected1 = false;
        posSelected2 = false;
        return;
    }
 }
 function tick() {
    count++;
    if (count % 60 === 0 && posSelected1 && posSelected2) {
        if (posSelected1) showEffectAtPos(pos1, [255, 0, 0], [255, 0, 50]);
        if (posSelected2) showEffectAtPos(pos2, [0, 105, 180], [0, 105, 180]);
        if (Obtained) {
            vertices.forEach(vertex => showEffectAtPos(vertex, [255, 255, 0], [255, 200, 0]));
            showEdges(vertices);
        }
    }
 }

function showEffectAtPos(position, minColor, maxColor) {
    api.playParticleEffect({
        dir1: [-1, -1, -1],
        dir2: [1, 1, 1],
        pos1: [position[0] - 0.5, position[1] - 0.5, position[2] - 0.5],
        pos2: [position[0] + 0.5, position[1] + 0.5, position[2] + 0.5],
        texture: "generic_2",
        minLifeTime: 0.5,
        maxLifeTime: 3,
        minEmitPower: 1,
        maxEmitPower: 2,
        minSize: 0.5,
        maxSize: 0.5,
        manualEmitCount: 40,
        gravity: [0, 0.01, 0],
        colorGradients: [{ timeFraction: 0, minColor, maxColor }],
        velocityGradients: [{ timeFraction: 0, factor: 0, factor2: 0 }],
        blendMode: 1
    });
 }

 function showEdges(vertices) {
    const edges = [
        [0, 1], [0, 2], [0, 4], [1, 3], [1, 5], [2, 3],
        [2, 6], [3, 7], [4, 5], [4, 6], [5, 7], [6, 7]
    ];

    edges.forEach(([startIdx, endIdx]) => {
        const start = vertices[startIdx];
        const end = vertices[endIdx];

        const steps = 10;
        for (let i = 0; i <= steps; i++) {
            const t = i / steps;
            const point = [
                start[0] + (end[0] - start[0]) * t,
                start[1] + (end[1] - start[1]) * t,
                start[2] + (end[2] - start[2]) * t
            ];
            showEffectAtPos(point, [255, 255, 255], [200, 200, 255]);
        }
    });
 }